import { ref } from 'vue'
import { ElMessage } from 'element-plus'
import CryptoJS from 'crypto-js'
import { domesticUserCenter } from 'ld-web-sdk';
import { userApi } from '@/api/user';
import { useUserStore } from '@/stores/user'
import { verifyConnectionQualification, applyConnectionSession } from '@/api/gaming.js'
import dialogManager from "@/utils/dialogManager.js";

// 用户store
// const userStore = useUserStore();


// 改进的AES解密函数
export function decryptWbLinkUrl(encryptedData, secretKey) {
  try {
    // 定义与Java代码相同的IV
    const IV = "encryptionIntVec";

    // 将密钥和IV转换为CryptoJS格式
    const key = CryptoJS.enc.Utf8.parse(secretKey);
    const iv = CryptoJS.enc.Utf8.parse(IV);

    // Base64解码
    const encryptedHexStr = CryptoJS.enc.Base64.parse(encryptedData);

    // 解密
    const decrypted = CryptoJS.AES.decrypt(
      { ciphertext: encryptedHexStr },
      key,
      {
        iv: iv,
        mode: CryptoJS.mode.CBC,
        padding: CryptoJS.pad.Pkcs7
      }
    );

    // 转换为UTF-8字符串
    const decryptedStr = decrypted.toString(CryptoJS.enc.Utf8);
    return decryptedStr;
  } catch (error) {
    console.error('AES解密失败:', error);
    return null;
  }
}

// 登录弹窗实例
let loginDialogInstance = null

// 设置登录弹窗实例
export const setLoginDialogInstance = (instance) => {
  loginDialogInstance = instance
}

// 获取登录弹窗实例
export const getLoginDialogInstance = () => {
  return loginDialogInstance
}

// 检查是否已登录
export const checkLogin = () => {
  const userStore = useUserStore()
  return userStore.isLoggedIn
}

// 显示登录弹窗
export const showLogin = () => {
  if (loginDialogInstance && loginDialogInstance.showLoginDialog) {
    loginDialogInstance.showLoginDialog()
  } else {
    ElMessage.error('登录组件未初始化，请确保已在App.vue中正确引入并注册LoginDialog组件')
  }
}

// 隐藏登录弹窗
export const hideLogin = () => {
  if (loginDialogInstance && loginDialogInstance.hideLoginDialog) {
    loginDialogInstance.hideLoginDialog()
  }
}

// 登录重定向处理
export const handleLoginRedirect = (callback) => {
  const userStore = useUserStore()
  if (userStore.isLoggedIn) {
    // 如果已登录，直接执行回调
    if (typeof callback === 'function') {
      callback()
    }
    return true
  } else {
    // 如果未登录，显示登录弹窗
    showLogin()
    // 监听登录成功事件，在登录成功后执行回调
    if (typeof callback === 'function') {
      // 这里需要结合具体的事件系统实现，或者在LoginDialog中提供回调机制
      const originalOnLoginSuccess = loginDialogInstance.onLoginSuccess
      loginDialogInstance.onLoginSuccess = (userData) => {
        if (originalOnLoginSuccess) {
          originalOnLoginSuccess(userData)
        }
        callback()
      }
    }
    return false
  }
}

// 权限检查装饰器
export const requireLogin = (target, key, descriptor) => {
  const originalMethod = descriptor.value
  descriptor.value = function (...args) {
    const userStore = useUserStore()
    if (userStore.isLoggedIn) {
      return originalMethod.apply(this, args)
    } else {
      showLogin()
      // 可以在这里设置登录成功后自动执行原方法的逻辑
      return null
    }
  }
  return descriptor
}

// 可组合的登录检查函数
export const useLoginCheck = () => {
  const isLoggedIn = ref(false)
  const userStore = useUserStore()

  // 初始化检查登录状态
  const checkStatus = () => {
    isLoggedIn.value = userStore.isLoggedIn
  }

  // 检查登录并执行操作
  const checkAndPerform = (callback) => {
    checkStatus()
    if (isLoggedIn.value) {
      if (typeof callback === 'function') {
        callback()
      }
      return true
    } else {
      showLogin()
      return false
    }
  }

  // 立即检查一次
  checkStatus()

  return {
    isLoggedIn,
    checkStatus,
    checkAndPerform,
    showLogin,
    hideLogin
  }
}

// 自动登录方法
export const auto = async (params = {}) => {
  try {
    // 获取登录信息
    const loginInfo = await domesticUserCenter.createLogin();
    const userStore = useUserStore()
    // 如果没有登录信息且参数中没有有效的auth或者userId，则抛出登录失败错误
    if (!loginInfo && (!params.auth || !params.userId)) {
      throw new Error('登录失败');
    }

    // 合并API请求参数
    const apiParams = {
      loginMode: "AUTO",  // 登录方式为自动登录
      auth: userStore.sign,  // 如果params有auth则使用，否则使用loginInfo中的token
      userId: userStore.uid,  // 如果params有userId则使用，否则使用loginInfo中的uid
      ...params  // 合并其他通用参数
    };

    // 调用用户登录API
    const res = await loginInfo.auto(apiParams);
    console.log("res.....", res);
    // 如果登录成功，更新用户存储
    if (res && res.code === 200) {
      const userData = {
        userInfo: res.data,
        token: res.data.token,
        sign: res.data.sign,
        uid: res.data.uid,
      }
      userStore.login(userData)
    }

    // 返回API返回结果
    return res;
  } catch (error) {
    console.error('自动登录失败:', error);
    throw error;
  }
}

/**
 * 通用 WebView 消息发送函数
 * @param {string} action - 要执行的操作
 * @param {Object} params - 要发送的参数对象
 * @returns {Promise<any>} 返回响应结果
 */
export const sendWebViewMessage = (action, params = {}) => {
  return new Promise((resolve, reject) => {
    // 检查 WebView 环境是否存在
    if (!window.chrome || !window.chrome.webview) {
      reject(new Error('WebView 环境不可用'))
      return
    }

    // 创建唯一的请求ID（需要在事件处理函数外部定义）
    const requestId = 'direct_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9)

    // 创建消息处理函数
    const messageHandler = (event) => {
      try {
        // 解析响应
        const response = typeof event.data === 'string' ? JSON.parse(event.data) : event.data

        // 检查是否是目标响应（兼容新旧格式）
        // 支持新的UnifiedResponse格式和旧的格式
        const isMatchingResponse = (
          (response.Action === action && response.RequestId === requestId) ||
          (response.type === `${action}Response` && response.requestId === requestId) ||
          (response.action === action && response.requestId === requestId)
        )
        if (isMatchingResponse) {
          // 移除事件监听器
          window.chrome.webview.removeEventListener('message', messageHandler)

          // 清除超时
          clearTimeout(timeoutId)

          // 解析响应数据（兼容新旧格式）
          const data = response.Data !== undefined ? response.Data :
            response.data !== undefined ? response.data :
              response.value !== undefined ? response.value : response

          // 检查成功状态（兼容新旧格式）
          const success = response.Success !== undefined ? response.Success :
            response.success !== undefined ? response.success : true

          if (success) {
            resolve(data)
          } else {
            const errorMsg = response.Error || response.error || '操作失败'
            reject(new Error(errorMsg))
          }
        }
      } catch (error) {
        // 注意：这里不移除监听器，因为可能是其他消息导致的解析错误
        console.warn('解析响应失败:', error)
      }
    }

    // 注册消息事件监听
    window.chrome.webview.addEventListener('message', messageHandler)

    // 设置超时机制
    const timeoutId = setTimeout(() => {
      window.chrome.webview.removeEventListener('message', messageHandler)
      reject(new Error('请求超时'))
    }, 5000) // 5秒超时

    // 创建消息（正确使用展开运算符）
    const message = {
      action: action,
      requestId: requestId,
      ...params // 展开所有其他参数
    }

    console.log(`发送 WebView 消息 [${action}]:`, JSON.stringify(message))

    // 发送消息到WebView
    window.chrome.webview.postMessage(message)
  })
}


/**
 * 与 WebView 通信导航到指定页面（参数可配置）
 * @param {Object} options - 配置选项
 * @param {string} options.url - 要导航到的页面URL
 * @param {string} options.action - 要执行的动作，默认为'navigate'
 * @param {any} [options.data] - 可选的附加数据
 * @param {string} [options.target] - 可选的目标窗口
 * @returns {Promise<boolean>} 返回导航是否成功
 */
export const navigateToPage = (options) => {
  return new Promise((resolve, reject) => {
    // 检查 WebView 环境是否存在
    if (!window.chrome || !window.chrome.webview) {
      reject(new Error('WebView 环境不可用'))
      return
    }

    // 创建唯一的请求ID
    const requestId = 'direct_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);

    // 创建消息处理函数
    const messageHandler = (event) => {
      try {
        // 解析响应
        const response = typeof event.data === 'string' ? JSON.parse(event.data) : event.data

        // 检查是否是目标响应
        if (response.type === 'navigateResponse' && response.requestId === requestId) {
          // 移除事件监听器
          window.chrome.webview.removeEventListener('message', messageHandler)

          // 清除超时
          clearTimeout(timeoutId)

          // 返回导航结果
          resolve(response.success)
        }
      } catch (error) {
        // 移除事件监听器
        window.chrome.webview.removeEventListener('message', messageHandler)
        // 清除超时
        clearTimeout(timeoutId)
        reject(new Error('解析响应失败: ' + error.message))
      }
    }

    // 注册消息事件监听
    window.chrome.webview.addEventListener('message', messageHandler)

    // 设置超时机制
    const timeoutId = setTimeout(() => {
      window.chrome.webview.removeEventListener('message', messageHandler)
      reject(new Error('请求超时'))
    }, 5000) // 5秒超时

    // 创建消息
    const message = {
      requestId: requestId,
      action: options.action || 'navigate',
      url: options.url,
      ...options // 展开所有其他选项
    }

    console.log('导航消息: ', JSON.stringify(message))

    // 发送消息到WebView
    window.chrome.webview.postMessage(message)
  })
}

/**
 * 与 WebView 通信获取 localStorage 值
 * @param {string} key - 要获取的 localStorage 键名
 * @returns {Promise<any>} 返回解析后的值
 */
export const getLocalStorageValue = (key) => {
  return new Promise((resolve, reject) => {
    // 检查 WebView 环境是否存在
    if (!window.chrome || !window.chrome.webview) {
      reject(new Error('WebView 环境不可用'))
      return
    }

    // 创建唯一的请求ID
    const requestId = 'request_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9)

    // 创建消息处理函数
    const messageHandler = (event) => {
      try {
        const response = typeof event.data === 'string' ? JSON.parse(event.data) : event.data;

        // 支持新的UnifiedResponse格式和旧的格式
        const isMatchingResponse = (
          // 新格式：UnifiedResponse
          (response.Action === 'localStorage_getItem' && response.RequestId === requestId) ||
          // 旧格式：兼容
          (response.type === 'localStorageResponse' && response.requestId === requestId)
        );

        if (isMatchingResponse) {
          // 从UnifiedResponse格式中提取值
          const value = response.Data !== undefined ? response.Data : response.value;
          resolve(value)
          window.chrome.webview.removeEventListener('message', messageHandler);
          clearTimeout(timeoutId); // 清除超时定时器
        }
      } catch (error) {
        reject(new Error('解析响应失败: ' + error.message))
        window.chrome.webview.removeEventListener('message', messageHandler);
      }
    }

    // 注册消息事件监听
    window.chrome.webview.addEventListener('message', messageHandler)

    // 设置超时机制
    const timeoutId = setTimeout(() => {
      window.chrome.webview.removeEventListener('message', messageHandler)
      reject(new Error('请求超时'))
    }, 5000) // 5秒超时

    // 创建消息
    const message = {
      action: 'localStorage_getItem',
      key: key,
      requestId: requestId
    }

    console.log('发送消息: ', JSON.stringify(message))

    // 发送消息到WebView
    window.chrome.webview.postMessage(message)
  })
}

/**
 * 与 WebView 通信设置 localStorage 值
 * @param {string} key - 要设置的 localStorage 键名
 * @param {any} value - 要设置的值
 * @returns {Promise<boolean>} 返回设置是否成功
 */
export const setLocalStorageValue = (key, value, requestName) => {
  return new Promise((resolve, reject) => {
    // 检查 WebView 环境是否存在
    if (!window.chrome || !window.chrome.webview) {
      reject(new Error('WebView 环境不可用'))
      return
    }

    // 创建唯一的请求ID
    const requestId = requestName + Date.now() + '_' + Math.random().toString(36).substr(2, 9)

    // 创建消息处理函数
    const messageHandler = (event) => {
      try {
        const response = typeof event.data === 'string' ? JSON.parse(event.data) : event.data;

        // 支持新的UnifiedResponse格式和旧的格式
        const isMatchingResponse = (
          // 新格式：UnifiedResponse
          (response.Action === 'localStorage_setItem' && response.RequestId === requestId) ||
          // 旧格式：兼容
          (response.type === 'localStorageResponse' && response.requestId === requestId)
        );

        if (isMatchingResponse) {
          // 从UnifiedResponse格式中提取值
          const value = response.Data !== undefined ? response.Data : response.value;
          resolve(value)
          window.chrome.webview.removeEventListener('message', messageHandler);
          clearTimeout(timeoutId); // 清除超时定时器
        }
      } catch (error) {
        reject(new Error('解析响应失败: ' + error.message))
        window.chrome.webview.removeEventListener('message', messageHandler);
      }
    }

    // 注册消息事件监听
    window.chrome.webview.addEventListener('message', messageHandler)

    // 设置超时机制
    const timeoutId = setTimeout(() => {
      window.chrome.webview.removeEventListener('message', messageHandler)
      reject(new Error('请求超时'))
    }, 5000) // 5秒超时

    // 创建消息
    const message = {
      action: 'localStorage_setItem',
      key: key,
      value: value,
      requestId: requestId
    }

    console.log('sz发送消息: ', JSON.stringify(message))

    // 发送消息到WebView
    window.chrome.webview.postMessage(message)
  })
}

/**
 * 获取所有配置信息
 * @returns {Promise<object>} 返回所有配置信息
 */
export const getAllConfig = () => {
  return new Promise((resolve, reject) => {
    // 检查 WebView 环境是否存在
    if (!window.chrome || !window.chrome.webview) {
      reject(new Error('WebView 环境不可用'))
      return
    }

    // 创建唯一的请求ID
    const requestId = 'request_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9)

    // 创建消息处理函数
    const messageHandler = (event) => {
      try {
        // 解析响应
        const response = typeof event.data === 'string' ? JSON.parse(event.data) : event.data

        // 检查是否是目标响应
        if (response.type === 'getAllConfigResponse' && response.requestId === requestId) {
          // 移除事件监听器
          window.chrome.webview.removeEventListener('message', messageHandler)

          // 清除超时
          clearTimeout(timeoutId)

          // 返回配置信息
          resolve(response.data)
        }
      } catch (error) {
        // 移除事件监听器
        window.chrome.webview.removeEventListener('message', messageHandler)
        // 清除超时
        clearTimeout(timeoutId)
        reject(new Error('解析响应失败: ' + error.message))
      }
    }

    // 注册消息事件监听
    window.chrome.webview.addEventListener('message', messageHandler)

    // 设置超时机制
    const timeoutId = setTimeout(() => {
      window.chrome.webview.removeEventListener('message', messageHandler)
      reject(new Error('请求超时'))
    }, 5000) // 5秒超时

    // 创建消息
    const message = {
      action: 'getAllConfig',
      requestId: requestId
    }

    console.log('发送消息: ', JSON.stringify(message))

    // 发送消息到WebView
    window.chrome.webview.postMessage(message)
  })
}

/**
 * 全局秒玩游戏处理函数
 * @param {string} targetId - 目标id:云游戏id或云电脑id
 * @param {string} targetType - 目标类型:1=云游戏;2=云电脑
 * @param {Function} onStatusChange - 状态变更回调函数，可选
 * @returns {Promise<void>}
 */
export const handlePlayGame = async (targetId, targetType, onStatusChange, useAccountWay = 1) => {
  // 状态管理
  const isPlaying = ref(false)

  // 状态变更通知
  const notifyStatusChange = (status, data) => {
    if (typeof onStatusChange === 'function') {
      onStatusChange(status, data)
    }
  }

  try {
    // 使用登录检查
    const { checkAndPerform } = useLoginCheck()

    // 检查登录并执行操作
    checkAndPerform(async () => {
      // 设置为播放状态
      isPlaying.value = true
      notifyStatusChange('loading')
      // 验证连接资格参数
      const verifyParams = {
        targetType: targetType || '1', // 目标类型:1=云游戏;2=云电脑，默认为1
        targetId: targetId // 目标id:云游戏id或云电脑id
      }

      try {
        // 验证连接资格
        const verifyRes = await verifyConnectionQualification(verifyParams)
        console.log('验证连接资格:', verifyRes)

        if (verifyRes.info.isPriorityEligible === true) {
          // 申请连接会话参数
          const sessionParams = {
            targetType: targetType || '1', // 目标类型:1=云游戏;2=云电脑，默认为1
            targetId: targetId, // 目标id:云游戏id或云电脑id
            useAccountWay: useAccountWay, // 使用游戏账号方式
            autoDestroy: true, // 是否自动注销其他正在连接的会话
            isGenerateWebLinkUrl: true // 是否生成网页链接地址
          }

          // 申请连接会话
          const sessionRes = await applyConnectionSession(sessionParams)
          const sessionData = sessionRes.session
          console.log('申请连接成功:', sessionRes)
          if (sessionData.accountStockInsufficient === true) {
            // 账号资源不足 弹窗
            dialogManager.showResourceInsufficientDialog(
              () => {
                // 取消
                notifyStatusChange('cancel')
              },
              () => {
                // 确认
                notifyStatusChange('confirm')
              }
            );
          } else {
            // 解密URL并跳转到游戏
            const key = "K7mN9pQxR3sTuvW2"
            const decryptedUrl = decryptWbLinkUrl(sessionData.webPlayUrl, key)
            console.log("解密后的链接:", decryptedUrl)

            // 自动登录
            const loginResult = await auto()

            if (loginResult && loginResult.code === 200) {
              // 跳转到游戏页面
              navigateToPage({
                cloudUrl: decryptedUrl,
                action: "cloud_connectServer",
                sessionData: {
                  targetType: targetType || "2",
                  targetId: targetId,
                },
                auth: { token: loginResult.data.sign, uid: loginResult.data.uid },
                recoverurl: window.location.href,
              })

              notifyStatusChange('navigating', { url: decryptedUrl })
            }
          }
        } else {
          notifyStatusChange('notEligible')
          isPlaying.value = false
        }
      } catch (error) {
        // 处理验证连接资格的错误
        console.error('验证连接资格失败:', error)
        notifyStatusChange('error', { error })
        isPlaying.value = false
      }
    })
  } catch (error) {
    console.error('玩游戏过程中出错:', error)
    notifyStatusChange('error', { error })
    isPlaying.value = false
  }
}